1. 字典的介绍
- 数据类型划分：可变数据类型 不可变数据类型
- 不可变数据类型: tuple(元组) bool int float str class可哈希
- 可变数据类型: list dict(字典) set(集合) 不可哈希
- 定义字典是 key 和 value 的数据类型
- key 必须是不可变数据类型
- value 任意类型
class Person(object):
pass
dic = {
'name': '字符串类型的key',
2: 'int类型的key',
3.2: 'float类型的key',
True: 'bool类型的key',
(1, 2, 3): 'tuple类型的key',
Person: '使用类作为key'
}
dic1 = dic['name']
dic2 = dic[2]
dic3 = dic[3.2]
dic4 = dic[True]
dic5 = dic[(1, 2, 3)]
dic6 = dic[Person]
- 注：3.5之前的版本（包括3.5）dict 都是无序的，3.5之后是有序的
2. 创建字典
- 普通创建
dic = {
name: 'Kevin'
age: 18
}
- dict() 创建
dict([('a', 1), ('b', 2), ('c', 3)]) # {'b': 2, 'a': 1, 'c': 3}
- fromkeys(keys, value) 创建 -> 以可迭代对象中的元素分别作为字典中的键，且所有键对应同一个值，默认值为 None -> 当某一个键值对中的值被修改其他键值对也会被修改，因为通过fromkeys创建的字典，其value值对应的是同一个内存地址
dic1 = dict.fromkeys([1, 2, 3]) # {1: None, 2: None, 3: None}
dic2 = dict.fromkeys([1, 2, 3], 'Kevin') # {1: 'Kevin', 2: 'Kevin', 3: 'Kevin'}
dic3 = dict.fromkeys(['key1', 'key2', 'key3'], []) # {'key2': [], 'key3': [], 'key1': []}
# 当某一个键值对中的值被修改其他键值对也会被修改
dic3['key2'].extend('姓名') # {'key2': ['姓', '名'], 'key3': ['姓', '名'], 'key1': ['姓', '名']}
dic3['key3'].append('value') # {'key2': ['value'], 'key3': ['value'], 'key1': ['value']}
3. 增
- dict[xxx] = xxx -> 没有键值对就添加，反之修改
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175
}
dict1['name'] = 'Yeung'
# 3.5 的结果 {'height': 175, 'name': 'Yeung', 'age': 18} -> 因为 3.5 之前都是无序的，所以排序不会和你设计的格式一样 3.6之后的不会这样
# 3.6 之后的结果 {'name': 'Yeung', 'age': 18, 'height': 175}
dict1['weight'] = 120
# 3.5 的结果 {'weight': 120, 'age': 18, 'name': 'Kevin', 'height': 175}
# 3.6 之后的结果 {'name': 'Kevin', 'age': 18, 'height': 175, 'weight': 120}
- .setdefault(key,val) -> 如果不设置 val 默认会添加 None -> 有键值对，不做任何改变，没有才添加。
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175
}
dict1.setdefault('weight') # {'age': 18, 'weight': None, 'height': 175, 'name': 'Kevin'}
dict1.setdefault('weight', 120) # {'weight': 120, 'age': 18, 'name': 'Kevin', 'height': 175}
dict1.setdefault('name', 'Yeung') # {'age': 18, 'name': 'Kevin', 'height': 175}
4. 删
- .pop(keyName,returnVal) -> returnVal: 当没有找到对应的键值对删除的时候会返回该值，如果 returnVal 为空在没有找到要删除的键值对的时候会报错
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175
}
dict1.pop('age') # 返回值 18
dict1.pop('age', None) # 返回值 18
dict1.pop('Kevin', None) # 返回值 None
dict1.pop('Kevin') # 报错
- .popitem() -> 返回值 元组 -> 3.5之前（包括3.5）随之删除，3.5之后删除最后一个 -> 没啥用
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175
}
dict1.popitem() # 返回值 元组 ('age', 18)
- .clear() -> 清空 dict(字典)
dict1.clear() # {}
- del dict['xxx'] -> 删除对应的键值对，如果没有找到会报错 -> 建议使用 .pop(keyName,returnVal)
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175
}
del dict1['name'] # {'height': 175, 'age': 18}
del dict1['kevin'] # 报错
- del dict -> 彻底从内存中删除该字典
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175
}
del dict1
5. 改
- dict[xxx] = xxx
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175
}
dict1['name'] = 'Yeung'
- dict2.update(dict1)
- 如果 dict1 的键值对和 dict2 的键值对相同，那么 dict1 的键值对会覆盖 dict2 的键值对，并且添加
- dict1 新的键值对会添加到 dict2 中
- dict1 的键值对始终不变
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175,
'address': '横沥'
}
dict2 = {
'name': 'Yeung',
'age': 19,
'weight': 120
}
dict2.update(dict1)
print(dict1) # {'address': '横沥', 'name': 'Kevin', 'age': 18, 'height': 175}
print(dict2) # {'name': 'Kevin', 'height': 175, 'address': '横沥', 'weight': 120, 'age': 18}
6. 查
- dict[xxx] -> 找不到对应的键值对会报错
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175,
'address': '横沥'
}
print('name') # Kevin
print('item') # 报错
- dict.get(keyName, returnVal) -> 找不到对应的键值对不会报错 -> returnVal 默认值 None -> 当没有找到对应的键值对的时候会返回returnVal -> 和 .pop() 类似
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175,
'address': '横沥'
}
print(dict1.get('name')) # Kevin
print(dict1.get('item')) # None
print(dict1.get('item', '没有该键')) # 没有该键
- dict.keys() -> 返回一个 所有字典中的 key 列表
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175,
'address': '横沥'
}
print(dict1.keys()) # dict_keys(['address', 'name', 'age', 'height'])
for k in dict1.keys():
print(k)
# 直接循环 dict 等同于 循环 dict.keys() 都是循环 键
for k in dict1:
print(k)
- dict.values() -> 返回一个 所有字典中的 value 列表 -> 最好不要使用，如果字典中的 value 值过大那么该方法所返回的 value 列表在内存中占用也会很大，建议使用 .keys() 或 直接循环 字典
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175,
'address': '横沥'
}
print(dict1.values()) # dict_values([175, 'Kevin', 18, '横沥'])
for k, v in dict1.values():
print(k, v)
- dict.items() -> 返回一个 所有字典中键值对的元组
dict1 = {
'name': 'Kevin',
'age': 18,
'height': 175,
'address': '横沥'
}
print(dict1.items()) # dict_items([('height', 175), ('name', 'Kevin'), ('age', 18), ('address', '横沥')])
for k, v in dict1.items():
print(k, v) # age 18 ……
← 推导式 数据类型 int 方法 →